/**
 * Trabajo de Ingeniería de Software 2
 * Año 2008
 * Sistema de Reserva de Recursos.
 * Desarrolladores: - Marcelo Ferreira.
 *                  - Christian Gómez.
 *                  - Marcelo Rodas.
 */
package controller;

import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;
import javax.persistence.Query;
import javax.faces.application.FacesMessage;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.faces.FacesException;
import java.util.HashMap;
import javax.transaction.UserTransaction;
import modelo.Estadosolicitud;
import modelo.Reserva;
import modelo.Recurso;
import modelo.Solicitudreserva;
import modelo.Tiporecurso;
import modelo.Usuario;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import javax.servlet.http.HttpSession;

import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Vector;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;

/**
 * Controlador de las Funcionalidades de una Solicitud de Reserva.
 * Utilizado para manejar la capa de controlador (MVC)
 * del sistema.
 * @author jmferreira
 * @version 1.0
 */
public class SolicitudreservaController extends HttpServlet implements SolicitudreservaControllerInterface {

    //JPA de la solicitud de reserva
    public Solicitudreserva solicitudreserva = null;
    //Lista de Solicitudes de reservas
    private List<Solicitudreserva> solicitudreservas = null;
    //Lista de Recursos
    private List<Recurso> recursos = null;
    //Variables para manejo de fechas en los formatos dd/mm/yyyy hh:mm
    DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
    DateFormat horaFormat = new SimpleDateFormat("HH:mm");
    DateFormat fechaHoraFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm");
    //Transaccion del usuario
    @Resource
    private UserTransaction utx = null;
    // Administrador de la Persistencia de la Solicitud de Reserva.
    // Relaciona al Controlador con el Modelo (MVC)
    @PersistenceUnit(unitName = "sistemaReservaPU")
    private EntityManagerFactory emf = null;

    /**
     * Obtiene el Administrador de Entidades.
     * @return EntityManager
     */
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }
    // ---------- Variables para paginar en el jsp -------------
    // variable auxiliar que indica el tamaño de conjunto
    public int batchSize = 100;
    // variable auxiliar para indicar el 1er elemento
    private int firstItem = 0;
    // variable auxiliar utilizado como contador de elementos
    private int itemCount = -1;
    // ---------------------------------------------------------

    /**
     * Contructor por defecto de la clase SolicitudreservaController
     */
    public SolicitudreservaController() {
        FacesContext context = FacesContext.getCurrentInstance();
        context.getExternalContext().getSessionMap().put("ListSolicitudesPendientes", this);
    }

    public SolicitudreservaController(Solicitudreserva solicitudreserva) {
        this.solicitudreserva = solicitudreserva;
    }
    
    /**
     * Fija una reservaCollectionList a la Solicitudreserva al valor especificado
     * @param reservaCollection La reservaCollection para la Solicitudreserva
     */
    public void setReservaCollectionOfSolicitudreserva(Reserva[] reservaCollection) {
        List<Reserva> reservaCollectionList = Arrays.asList(reservaCollection);
        solicitudreserva.setReservaCollection(reservaCollectionList);
    }

    /**
     * Obtiene una reservaCollectionList a la Solicitudreserva
     * @return Una reservaCollectionList de la Solicitudreserva
     */
    public Reserva[] getReservaCollectionOfSolicitudreserva() {
        Collection<Reserva> reservaCollection = solicitudreserva.getReservaCollection();
        if (reservaCollection == null) {
            return new Reserva[0];
        }
        return reservaCollection.toArray(new Reserva[0]);
    }

    /**
     * Obtiene el listado de Solicitudreserva en una lista iterada
     * @return La lista de Solicitudreserva
     */
    public SelectItem[] getSolicitudreservasAvailableSelectMany() {
        return getSolicitudreservasAvailable(false);
    }

    /**
     * Metodo publico para obtener una lista de las Solicitudreserva's disponibles de una sola seleccion
     * @return lista de Solicitudreserva
     */
    public SelectItem[] getSolicitudreservasAvailableSelectOne() {
        return getSolicitudreservasAvailable(true);
    }

    private SelectItem[] getSolicitudreservasAvailable(boolean one) {
        List<Solicitudreserva> allSolicitudreservas = getSolicitudreservas(true);
        int size = one ? allSolicitudreservas.size() + 1 : allSolicitudreservas.size();
        SelectItem[] items = new SelectItem[size];
        int i = 0;
        if (one) {
            items[0] = new SelectItem("", "---");
            i++;
        }
        for (Solicitudreserva x : allSolicitudreservas) {
            items[i++] = new SelectItem(x, x.toString());
        }
        return items;
    }

    /**
     * Obtiene la la Solicitudreserva si es que existe, y si no, crea una nueva instancia
     * @return La Solicitudreserva
     */
    public Solicitudreserva getSolicitudreserva() {
        if (solicitudreserva == null) {
            solicitudreserva = getSolicitudreservaFromRequest();
        }
        if (solicitudreserva == null) {
            solicitudreserva = new Solicitudreserva();
        }
        return solicitudreserva;
    }

    /**
     * Metodo para resetear los valores de inicio y llamar al Tag de Lista de Solicitudreserva
     * @return el tag de la Lista de Solicitudreserva
     */
    public String listSetup() {
        reset(true);
        return "solicitudreserva_list";
    }

    /**
     * Metodo para inicializar los valores para el operador del Objeto Solicitudreserva para un nuevo objeto
     * @return el Tag del JSP para crear una nueva entrada de Solicitudreserva
     */
    public String createSetup() {
        reset(false);
        solicitudreserva = new Solicitudreserva(this.getItemMax());
        solicitudreserva.setIdEstadoSolicitud(new Estadosolicitud(3));
        solicitudreserva.setFechaInicio(new Date());
        solicitudreserva.setHoraInicio(new Date());
        solicitudreserva.setFechaFin(new Date());
        solicitudreserva.setHoraFin(new Date());

        return "solicitudreserva_create";
    }

    /**
     * Metodo para inicializar los valores para el solicitante del Objeto Solicitudreserva para un nuevo objeto
     * @return el Tag del JSP para crear una nueva entrada de Solicitudreserva
     */
    public String createSetupSolicitante() {
        reset(false);
        solicitudreserva = new Solicitudreserva(this.getItemMax());
        solicitudreserva.setIdEstadoSolicitud(new Estadosolicitud(3));
        solicitudreserva.setFechaInicio(new Date());
        solicitudreserva.setHoraInicio(new Date());
        solicitudreserva.setFechaFin(new Date());
        solicitudreserva.setHoraFin(new Date());

        return "solicitudreservaSolicitante_create";
    }

    /**
     * Realiza la creacion de una nueva solicitud de reserva.
     * Para ello obtiene la clase instanciada de <code>solicitudreserva</code>
     * y a través del EntityManager realiza la operación de transacción
     * @return El tag donde se redireccionará la pagina actual despues de que haya terminado la transaccion
     */
    public String create() {
        //Obtener los atributos de la sesion
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        Usuario idSolicitante;
        if (solicitudreserva.getReservaCollection() == null) {
            solicitudreserva.setReservaCollection(new ArrayList<Reserva>());
        }
        try {
            this.solicitudreserva.setFechaInicio(dateFormat.parse(this.getRequestParameter("fechaInicio")));
            this.solicitudreserva.setHoraInicio(horaFormat.parse(this.getRequestParameter("horaInicio")));
            this.solicitudreserva.setFechaFin(dateFormat.parse(this.getRequestParameter("fechaFin")));
            this.solicitudreserva.setHoraFin(horaFormat.parse(this.getRequestParameter("horaFin")));
        } catch (Exception e) {
            addErrorMessage("Error en los formatos de fechas y horas");
            return "";
        }
        try {
            Date inicio = fechaHoraFormat.parse(this.getRequestParameter("fechaInicio") + " " + this.getRequestParameter("horaInicio"));
            Date fin = fechaHoraFormat.parse(this.getRequestParameter("fechaFin") + " " + this.getRequestParameter("horaFin"));
            inicio.setMinutes(inicio.getMinutes() + 1);
            //Validar el rango de fecha
            if (inicio.after(fin)) {
                addErrorMessage("La FECHA de Finalizacion debe ser mayor a la FECHA de Inicio");
                return "";
            }

        } catch (Exception e) {
            addErrorMessage("Error en los formatos de fechas y horas");
            return "";
        }

        //Obtener el Administrador de Entidades
        EntityManager em = getEntityManager();
        try {
            //Iniciar la transaccion del usuario
            utx.begin();
            //Asentar todos los valores de la clase para realizar el matcheo con los atributos
            //de la base de datos
            Estadosolicitud idEstadoSolicitud = solicitudreserva.getIdEstadoSolicitud();
            if (idEstadoSolicitud != null) {
                idEstadoSolicitud = em.getReference(idEstadoSolicitud.getClass(), idEstadoSolicitud.getIdEstadoSolicitud());
                solicitudreserva.setIdEstadoSolicitud(idEstadoSolicitud);
            }
            Tiporecurso idTipoRecurso = solicitudreserva.getIdTipoRecurso();
            if (idTipoRecurso != null) {
                idTipoRecurso = em.getReference(idTipoRecurso.getClass(), idTipoRecurso.getIdTipoRecurso());
                solicitudreserva.setIdTipoRecurso(idTipoRecurso);
            }
            idSolicitante = solicitudreserva.getIdSolicitante();

            if (idSolicitante != null) { //El aprobador realiza la solicitud a nombre del solicitante

                idSolicitante = em.getReference(idSolicitante.getClass(), idSolicitante.getIdUsuario());
                solicitudreserva.setIdSolicitante(idSolicitante);
            } else { //El solicitante es el que realiza la solicitud

                Usuario usuario1 = (Usuario) session.getAttribute("user");
                solicitudreserva.setIdSolicitante(usuario1);
            }

            List<Reserva> attachedReservaCollection = new ArrayList<Reserva>();
            for (Reserva reservaCollectionReservaToAttach : solicitudreserva.getReservaCollection()) {
                reservaCollectionReservaToAttach = em.getReference(reservaCollectionReservaToAttach.getClass(), reservaCollectionReservaToAttach.getIdReserva());
                attachedReservaCollection.add(reservaCollectionReservaToAttach);
            }
            solicitudreserva.setReservaCollection(attachedReservaCollection);
            em.persist(solicitudreserva);
            if (idEstadoSolicitud != null) {
                idEstadoSolicitud.getSolicitudreservaCollection().add(solicitudreserva);
                idEstadoSolicitud = em.merge(idEstadoSolicitud);
            }
            if (idTipoRecurso != null) {
                idTipoRecurso.getSolicitudreservaCollection().add(solicitudreserva);
                idTipoRecurso = em.merge(idTipoRecurso);
            }
            if (idSolicitante != null) {
                idSolicitante.getSolicitudreservaCollection().add(solicitudreserva);
                idSolicitante = em.merge(idSolicitante);
            }
            for (Reserva reservaCollectionReserva : solicitudreserva.getReservaCollection()) {
                Solicitudreserva oldIdSolicitudReservaOfReservaCollectionReserva = reservaCollectionReserva.getIdSolicitudReserva();
                reservaCollectionReserva.setIdSolicitudReserva(solicitudreserva);
                reservaCollectionReserva = em.merge(reservaCollectionReserva);
                if (oldIdSolicitudReservaOfReservaCollectionReserva != null) {
                    oldIdSolicitudReservaOfReservaCollectionReserva.getReservaCollection().remove(reservaCollectionReserva);
                    oldIdSolicitudReservaOfReservaCollectionReserva = em.merge(oldIdSolicitudReservaOfReservaCollectionReserva);
                }
            }
            //Para la audioria, que dispara el trigger de auditoria
            Usuario usuarioLogeado = (Usuario) session.getAttribute("user");
            solicitudreserva.setUserAudita(usuarioLogeado.getIdUsuario());
            //

            utx.commit();
            addSuccessMessage("Solicitud Reserva fue creado exitosamente.");
        } catch (Exception ex) { //Maneja el evento de la transaccion del usuario

            try {
                if (findSolicitudreserva(solicitudreserva.getIdSolicitudReserva()) != null) {
                    addErrorMessage("Solicitudreserva " + solicitudreserva + " already exists.");
                } else {
                    ensureAddErrorMessage(ex, "A persistence error occurred.");
                }
                utx.rollback();
            } catch (Exception e) { //Maneja el evento del rollback de la transaccion

                ensureAddErrorMessage(e, "An error occurred attempting to roll back the transaction.");
            }
            return null;
        } finally { //Cerrar el administrador de entidades

            em.close();
        }
        if (idSolicitante != null) { //El aprobador realiza la solicitud a nombre del solicitante

            reset(true);
            return "menuSolicitudReserva";
        } else {
            return listSolicitudesPendientesSolicitanteSetup();
        }
//        return createSetup();
    }
    /*
    public String detailSetup() {
    return scalarSetup("solicitudreserva_detail");
    }
    
    public String editSetup() {
    return scalarSetup("solicitudreserva_edit");
    }
     */

    /**
     * Función de Navegación General, controla si existe la ruta de
     * navegación.
     * @param destination
     * @return El tag de destino
     */
    private String scalarSetup(String destination) {
        reset(false);
        solicitudreserva = getSolicitudreservaFromRequest();
        if (solicitudreserva == null) {
            String requestSolicitudreservaString = getRequestParameter("jsfcrud.currentSolicitudreserva");
            addErrorMessage("The solicitudreserva with id " + requestSolicitudreservaString + " no longer exists.");
            String relatedControllerOutcome = relatedControllerOutcome();
            if (relatedControllerOutcome != null) {
                return relatedControllerOutcome;
            }
            return listSetup();
        }
        FacesContext context = FacesContext.getCurrentInstance();
        context.getExternalContext().getSessionMap().put("fecha_inicio", dateFormat.format(solicitudreserva.getFechaInicio()));
        context.getExternalContext().getSessionMap().put("hora_inicio", horaFormat.format(solicitudreserva.getHoraInicio()));
        context.getExternalContext().getSessionMap().put("fecha_fin", dateFormat.format(solicitudreserva.getFechaFin()));
        context.getExternalContext().getSessionMap().put("hora_fin", horaFormat.format(solicitudreserva.getHoraFin()));

        return destination;
    }
    /*
    public String edit() {
    SolicitudreservaConverter converter = new SolicitudreservaConverter();
    String solicitudreservaString = converter.getAsString(FacesContext.getCurrentInstance(), null, solicitudreserva);
    String currentSolicitudreservaString = getRequestParameter("jsfcrud.currentSolicitudreserva");
    if (solicitudreservaString == null || solicitudreservaString.length() == 0 || !solicitudreservaString.equals(currentSolicitudreservaString)) {
    String outcome = editSetup();
    if ("solicitudreserva_edit".equals(outcome)) {
    addErrorMessage("Could not edit solicitudreserva. Try again.");
    }
    return outcome;
    }
    EntityManager em = getEntityManager();
    try {
    utx.begin();
    Solicitudreserva persistentSolicitudreserva = em.find(Solicitudreserva.class, solicitudreserva.getIdSolicitudReserva());
    Estadosolicitud idEstadoSolicitudOld = persistentSolicitudreserva.getIdEstadoSolicitud();
    Estadosolicitud idEstadoSolicitudNew = solicitudreserva.getIdEstadoSolicitud();
    Tiporecurso idTipoRecursoOld = persistentSolicitudreserva.getIdTipoRecurso();
    Tiporecurso idTipoRecursoNew = solicitudreserva.getIdTipoRecurso();
    Usuario idSolicitanteOld = persistentSolicitudreserva.getIdSolicitante();
    Usuario idSolicitanteNew = solicitudreserva.getIdSolicitante();
    Collection<Reserva> reservaCollectionOld = persistentSolicitudreserva.getReservaCollection();
    Collection<Reserva> reservaCollectionNew = solicitudreserva.getReservaCollection();
    if (idEstadoSolicitudNew != null) {
    idEstadoSolicitudNew = em.getReference(idEstadoSolicitudNew.getClass(), idEstadoSolicitudNew.getIdEstadoSolicitud());
    solicitudreserva.setIdEstadoSolicitud(idEstadoSolicitudNew);
    }
    if (idTipoRecursoNew != null) {
    idTipoRecursoNew = em.getReference(idTipoRecursoNew.getClass(), idTipoRecursoNew.getIdTipoRecurso());
    solicitudreserva.setIdTipoRecurso(idTipoRecursoNew);
    }
    if (idSolicitanteNew != null) {
    idSolicitanteNew = em.getReference(idSolicitanteNew.getClass(), idSolicitanteNew.getIdUsuario());
    solicitudreserva.setIdSolicitante(idSolicitanteNew);
    }
    List<Reserva> attachedReservaCollectionNew = new ArrayList<Reserva>();
    for (Reserva reservaCollectionNewReservaToAttach : reservaCollectionNew) {
    reservaCollectionNewReservaToAttach = em.getReference(reservaCollectionNewReservaToAttach.getClass(), reservaCollectionNewReservaToAttach.getIdReserva());
    attachedReservaCollectionNew.add(reservaCollectionNewReservaToAttach);
    }
    reservaCollectionNew = attachedReservaCollectionNew;
    solicitudreserva.setReservaCollection(reservaCollectionNew);
    solicitudreserva = em.merge(solicitudreserva);
    if (idEstadoSolicitudOld != null && !idEstadoSolicitudOld.equals(idEstadoSolicitudNew)) {
    idEstadoSolicitudOld.getSolicitudreservaCollection().remove(solicitudreserva);
    idEstadoSolicitudOld = em.merge(idEstadoSolicitudOld);
    }
    if (idEstadoSolicitudNew != null && !idEstadoSolicitudNew.equals(idEstadoSolicitudOld)) {
    idEstadoSolicitudNew.getSolicitudreservaCollection().add(solicitudreserva);
    idEstadoSolicitudNew = em.merge(idEstadoSolicitudNew);
    }
    if (idTipoRecursoOld != null && !idTipoRecursoOld.equals(idTipoRecursoNew)) {
    idTipoRecursoOld.getSolicitudreservaCollection().remove(solicitudreserva);
    idTipoRecursoOld = em.merge(idTipoRecursoOld);
    }
    if (idTipoRecursoNew != null && !idTipoRecursoNew.equals(idTipoRecursoOld)) {
    idTipoRecursoNew.getSolicitudreservaCollection().add(solicitudreserva);
    idTipoRecursoNew = em.merge(idTipoRecursoNew);
    }
    if (idSolicitanteOld != null && !idSolicitanteOld.equals(idSolicitanteNew)) {
    idSolicitanteOld.getSolicitudreservaCollection().remove(solicitudreserva);
    idSolicitanteOld = em.merge(idSolicitanteOld);
    }
    if (idSolicitanteNew != null && !idSolicitanteNew.equals(idSolicitanteOld)) {
    idSolicitanteNew.getSolicitudreservaCollection().add(solicitudreserva);
    idSolicitanteNew = em.merge(idSolicitanteNew);
    }
    for (Reserva reservaCollectionOldReserva : reservaCollectionOld) {
    if (!reservaCollectionNew.contains(reservaCollectionOldReserva)) {
    reservaCollectionOldReserva.setIdSolicitudReserva(null);
    reservaCollectionOldReserva = em.merge(reservaCollectionOldReserva);
    }
    }
    for (Reserva reservaCollectionNewReserva : reservaCollectionNew) {
    if (!reservaCollectionOld.contains(reservaCollectionNewReserva)) {
    Solicitudreserva oldIdSolicitudReservaOfReservaCollectionNewReserva = reservaCollectionNewReserva.getIdSolicitudReserva();
    reservaCollectionNewReserva.setIdSolicitudReserva(solicitudreserva);
    reservaCollectionNewReserva = em.merge(reservaCollectionNewReserva);
    if (oldIdSolicitudReservaOfReservaCollectionNewReserva != null && !oldIdSolicitudReservaOfReservaCollectionNewReserva.equals(solicitudreserva)) {
    oldIdSolicitudReservaOfReservaCollectionNewReserva.getReservaCollection().remove(reservaCollectionNewReserva);
    oldIdSolicitudReservaOfReservaCollectionNewReserva = em.merge(oldIdSolicitudReservaOfReservaCollectionNewReserva);
    }
    }
    }
    utx.commit();
    addSuccessMessage("Solicitudreserva was successfully updated.");
    } catch (Exception ex) {
    try {
    String msg = ex.getLocalizedMessage();
    if (msg != null && msg.length() > 0) {
    addErrorMessage(msg);
    } else if (getSolicitudreservaFromRequest() == null) {
    addErrorMessage("The solicitudreserva with id " + currentSolicitudreservaString + " no longer exists.");
    utx.rollback();
    return listSetup();
    } else {
    addErrorMessage("A persistence error occurred.");
    }
    utx.rollback();
    } catch (Exception e) {
    ensureAddErrorMessage(e, "An error occurred attempting to roll back the transaction.");
    }
    return null;
    } finally {
    em.close();
    }
    return detailSetup();
    }
     */

    /**
     * Obtiene una instancia de la Solicitudreserva de la peticion
     * @return Solicitudreserva La Solicitudreserva encontrada
     */
    private Solicitudreserva getSolicitudreservaFromRequest() {
        String theId = getRequestParameter("jsfcrud.currentSolicitudreserva");
        return (Solicitudreserva) new SolicitudreservaConverter().getAsObject(FacesContext.getCurrentInstance(), null, theId);
    }
    /*
     * Función para obtener un valor del request.
     */

    private String getRequestParameter(String key) {
        return FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get(key);
    }

    /**
     * Getter de Solicitudreserva (atributo local).
     * @return List<Solicitudreserva>
     */
    public List<Solicitudreserva> getSolicitudreservas() {
        if (solicitudreservas == null) {
            solicitudreservas = getSolicitudreservas(false);
        }
        return solicitudreservas;
    }

    /**
     * Getter de todos los Solicitudreserva's (de la Base de Datos)
     * @param all
     * @return List<Solicitudreserva>
     */
    public List<Solicitudreserva> getSolicitudreservas(boolean all) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Solicitudreserva as o");
            if (!all) {
                q.setMaxResults(batchSize);
                q.setFirstResult(getFirstItem());
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    /**
     * Asegura que se obtenga el error correcto y agrega un mensaje por defecto
     * si no localiza el origen del error
     */
    private void ensureAddErrorMessage(Exception ex, String defaultMsg) {
        String msg = ex.getLocalizedMessage();
        if (msg != null && msg.length() > 0) {
            addErrorMessage(msg);
        } else {
            addErrorMessage(defaultMsg);
        }
    }

    /**
     * Agrega mensajes de Error para la Página.
     * @param msg El mensaje a ser agregado a la pagina
     */
    public static void addErrorMessage(String msg) {
        FacesMessage facesMsg = new FacesMessage(FacesMessage.SEVERITY_ERROR, msg, msg);
        FacesContext.getCurrentInstance().addMessage(null, facesMsg);
    }

    /**
     * Agrega mensajes de éxito para la Página.
     * @param msg El mensaje a ser agregado a la pagina
     */
    public static void addSuccessMessage(String msg) {
        FacesMessage facesMsg = new FacesMessage(FacesMessage.SEVERITY_INFO, msg, msg);
        FacesContext.getCurrentInstance().addMessage("successInfo", facesMsg);
    }

    /**
     * Obtiene una SolicitudReserva con el id correspondiente.
     * @param id El idSolicitudReserva correspondiente
     * @return Solicitudreserva
     */
    public Solicitudreserva findSolicitudreserva(Integer id) {
        EntityManager em = getEntityManager();
        try {
            Solicitudreserva o = (Solicitudreserva) em.find(Solicitudreserva.class, id);
            return o;
        } finally {
            em.close();
        }
    }

    /**
     * ------------------------------------------
     * Funciones de Iteración
     * ------------------------------------------
     */
    /**
     * Obtiene la cantidad de items de la Solicitudreserva
     * @return La cantidad de items
     */
    public int getItemCount() {
        if (itemCount == -1) {
            EntityManager em = getEntityManager();
            try {
                itemCount = ((Long) em.createQuery("select count(o) from Solicitudreserva as o").getSingleResult()).intValue();
            } finally {
                em.close();
            }
        }
        return itemCount;
    }

    /**
     * Obtiene el primer item de la Solicitudreserva
     * @return El primer item
     */
    public int getFirstItem() {
        getItemCount();
        if (firstItem >= itemCount) {
            if (itemCount == 0) {
                firstItem = 0;
            } else {
                int zeroBasedItemCount = itemCount - 1;
                double pageDouble = zeroBasedItemCount / batchSize;
                int page = (int) Math.floor(pageDouble);
                firstItem = page * batchSize;
            }
        }
        return firstItem;
    }

    /**
     * Obtiene el ultimo item de la Solicitudreserva
     * @return El ultimo item
     */
    public int getLastItem() {
        getFirstItem();
        return firstItem + batchSize > itemCount ? itemCount : firstItem + batchSize;
    }

    /**
     * Obtiene tamaño del buffer para desplegar la lista
     * @return El tamaño del buffer
     */
    public int getBatchSize() {
        return batchSize;
    }

    /**
     * Obtiene la siguiente coleccion de items de solicitudReserva
     * conforme al BatchSize
     * @return La siguiente coleccion de items
     */
    public String next() {
        reset(false);
        getFirstItem();
        if (firstItem + batchSize < itemCount) {
            firstItem += batchSize;
        }
        return "solicitudreserva_list";
    }

    /**
     * Obtiene la anterior coleccion de items de solicitudReserva
     * conforme al BatchSize
     * @return La anterior coleccion de items
     */
    public String prev() {
        reset(false);
        getFirstItem();
        firstItem -= batchSize;
        if (firstItem < 0) {
            firstItem = 0;
        }
        return "solicitudreserva_list";
    }

    private String relatedControllerOutcome() {
        String relatedControllerString = getRequestParameter("jsfcrud.relatedController");
        String relatedControllerTypeString = getRequestParameter("jsfcrud.relatedControllerType");
        if (relatedControllerString != null && relatedControllerTypeString != null) {
            FacesContext context = FacesContext.getCurrentInstance();
            Object relatedController = context.getApplication().getELResolver().getValue(context.getELContext(), null, relatedControllerString);
            try {
                Class<?> relatedControllerType = Class.forName(relatedControllerTypeString);
                Method detailSetupMethod = relatedControllerType.getMethod("detailSetup");
                return (String) detailSetupMethod.invoke(relatedController);
            } catch (ClassNotFoundException e) {
                throw new FacesException(e);
            } catch (NoSuchMethodException e) {
                throw new FacesException(e);
            } catch (IllegalAccessException e) {
                throw new FacesException(e);
            } catch (InvocationTargetException e) {
                throw new FacesException(e);
            }
        }
        return null;
    }

    /**
     * Borra la referencia al objeto Representado (Borrado sin persistencia).
     * @param resetFirstItem
     */
    public void reset(boolean resetFirstItem) {
        solicitudreserva = null;
        solicitudreservas = null;
        itemCount = -1;
        if (resetFirstItem) {
            firstItem = 0;
        }
    }
    private Map<Object, String> asString = null;

    /**
     * Obtiene el mapeo del objeto actual en su representacion String
     * @return Mapeo de <code>Object, String</code>
     */
    public Map<Object, String> getAsString() {
        if (asString == null) {
            asString = new HashMap<Object, String>() {

                @Override
                public String get(Object key) {
                    if (key instanceof Object[]) {
                        Object[] keyAsArray = (Object[]) key;
                        if (keyAsArray.length == 0) {
                            return "(No Items)";
                        }
                        StringBuffer sb = new StringBuffer();
                        for (int i = 0; i < keyAsArray.length; i++) {
                            if (i > 0) {
                                sb.append("<br />");
                            }
                            sb.append(keyAsArray[i]);
                        }
                        return sb.toString();
                    }
                    return new SolicitudreservaConverter().getAsString(FacesContext.getCurrentInstance(), null, (Solicitudreserva) key);
                }
            };
        }
        return asString;
    }

    /**
     * Función que Vincula y Valida JSP con la Solicitudreserva representada.
     * @param facesContext El contexto del faces
     * @param component
     * @param value
     */
    public void validateCreate(FacesContext facesContext, UIComponent component, Object value) {
        SolicitudreservaConverter converter = new SolicitudreservaConverter();
        String newSolicitudreservaString = converter.getAsString(FacesContext.getCurrentInstance(), null, new Solicitudreserva());
        String solicitudreservaString = converter.getAsString(FacesContext.getCurrentInstance(), null, solicitudreserva);
        if (!newSolicitudreservaString.equals(solicitudreservaString)) {
            createSetup();
        }
    }

    /**
     * Resetea la referencia del objeto y retorna el tag de la siguiente pagina a desplegar
     * @return El tag de la siguiente pagina
     */
    public String listSolicitudesPendientes() {
        reset(true);
        return "ListSolicitudesPendientes";
    }

    /**
     * Obtiene la lista iterada de SolicitudReservas pendientes
     * @return La lista iterada de SolicitudReservas pendientes
     * Si el objeto actual es nulo, retorna la nueva lista de pendientes,
     * caso contrario, retorna la lista de pendientes actual
     */
    public List<Solicitudreserva> getSolicitudreservasPendientes() {
        if (solicitudreservas == null) {
            solicitudreservas = getSolicitudreservasPendientes(false);
        }
        return solicitudreservas;
    }

    /**
     * Obtiene la lista iterada de una Solicitudreserva pendinte
     * @param all Un boolean indicando que se recupere todos los valores
     * @return La lista iterada de pendientes
     */
    public List<Solicitudreserva> getSolicitudreservasPendientes(boolean all) {
        EntityManager em = getEntityManager();
        try {
            //Es el select de solamente las solicitudes con estado pendientes
            Query q = em.createQuery("select object(o) from Solicitudreserva as o where o.idEstadoSolicitud.idEstadoSolicitud=3");
            if (!all) {
                q.setMaxResults(batchSize);
                q.setFirstResult(getFirstItem());
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    /**
     * Obtiene el tag de la pagina de aprobacion de una solicitudreserva
     * @return El tag de la pagina de aprobacion de una solicitudreserva 
     */
    public String aprobarSetup() {
        //reset(false);
        return scalarSetup("solicitudreserva_aprobar");
    }

    /**
     * Obtiene el tag de la pagina de rechazo de una solicitudreserva
     * @return El tag de la pagina de rechazo de una solicitudreserva 
     */
    public String rechazarSetup() {
        return scalarSetup("solicitudreserva_rechazar");
    }

    /**
     * Obtiene el tag de la pagina de anulacion de una solicitudreserva
     * @return El tag de la pagina de anulacion de una solicitudreserva 
     */
    public String anularSetup() {
        return scalarSetup("solicitudreserva_anular");
    }

    /**
     * Realiza la transaccion de usuario que se encarga de rechazar una solicitudreserva.
     * Para ello realiza el chequeo de todos los valores antes de realizar el matcheo con los
     * atributos del JPA de la Base de Datos
     * @return El tag de la pagina que lista las solicitudes reservas pendientes
     */
    public String rechazar() {
        //Recupera los atributos de la sesion
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        SolicitudreservaConverter converter = new SolicitudreservaConverter();
        //Obtiene la clave de la solicitud reserva a rechazar
        String solicitudreservaString = converter.getAsString(FacesContext.getCurrentInstance(), null, solicitudreserva);
        String currentSolicitudreservaString = getRequestParameter("jsfcrud.currentSolicitudreserva");
        //Verifica que exista la solicitud reserva o que se haya seleccionado alguna disponible
        if (solicitudreservaString == null || solicitudreservaString.length() == 0 || !solicitudreservaString.equals(currentSolicitudreservaString)) {
            String outcome = rechazarSetup();
            if ("solicitudreserva_rechazar".equals(outcome)) {
                addErrorMessage("No se pudo realizar la operacion. Intente de nuevo.");
            }
            return outcome;
        }
        //Obtiene el administador de entidades
        EntityManager em = getEntityManager();
        try {
            utx.begin();
            //-- Se asigna todos los valores necesarios para el rechazo --
            Usuario idaprobadorNew = (Usuario) session.getAttribute("user");
            Estadosolicitud idEstadoSolicitudNew = new Estadosolicitud(2); //Estado 2-RECHAZADO

            Tiporecurso idTipoRecursoNew = solicitudreserva.getIdTipoRecurso();
            Usuario idSolicitanteNew = solicitudreserva.getIdSolicitante();

            solicitudreserva.setFechaAprobacion(this.getFechaHoraActual());
            solicitudreserva.setHoraAprobacion(this.getFechaHoraActual());
            if (idEstadoSolicitudNew != null) {
                idEstadoSolicitudNew = em.getReference(idEstadoSolicitudNew.getClass(), idEstadoSolicitudNew.getIdEstadoSolicitud());
                solicitudreserva.setIdEstadoSolicitud(idEstadoSolicitudNew);
            }
            if (idTipoRecursoNew != null) {
                idTipoRecursoNew = em.getReference(idTipoRecursoNew.getClass(), idTipoRecursoNew.getIdTipoRecurso());
                solicitudreserva.setIdTipoRecurso(idTipoRecursoNew);
            }
            if (idSolicitanteNew != null) {
                idSolicitanteNew = em.getReference(idSolicitanteNew.getClass(), idSolicitanteNew.getIdUsuario());
                solicitudreserva.setIdSolicitante(idSolicitanteNew);
            }
            if (idaprobadorNew != null) {
                idaprobadorNew = em.getReference(idaprobadorNew.getClass(), idaprobadorNew.getIdUsuario());
                solicitudreserva.setIdAprobador(idaprobadorNew);
            }
            solicitudreserva = em.merge(solicitudreserva);
            //Para la audioria, que dispara el trigger de auditoria
            Usuario usuarioLogeado = (Usuario) session.getAttribute("user");
            solicitudreserva.setUserAudita(usuarioLogeado.getIdUsuario());
            utx.commit();
            addSuccessMessage("Solicitudreserva rechazado exitosamente.");
        } catch (Exception ex) { //Maneja el evento de la transaccion de usuario

            try {
                String msg = ex.getLocalizedMessage();
                if (msg != null && msg.length() > 0) {
                    addErrorMessage(msg);
                } else if (getSolicitudreservaFromRequest() == null) {
                    addErrorMessage("La solicitudreserva con id " + currentSolicitudreservaString + " no existe.");
                    utx.rollback();
                    return listSetup();
                } else {
                    addErrorMessage("Ocurrio un error de persistencia.");
                }
                utx.rollback();
            } catch (Exception e) { //Maneja el evento del rollback de la transaccion

                ensureAddErrorMessage(e, "Ocurrio un error intentando hacer rollback de la transaccion.");
            }
            return null;
        } finally {
            em.close();
        }
        return this.listSolicitudesPendientes();
    }

    /**
     * Realiza la transaccion de usuario que se encarga de anular una solicitudreserva.
     * Para ello realiza el chequeo de todos los valores antes de realizar el matcheo con los
     * atributos del JPA de la Base de Datos
     * @return El tag de la pagina que lista las solicitudes reservas pendientes
     */
    public String anular() {
        //Recupera los atributos de la sesion
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        SolicitudreservaConverter converter = new SolicitudreservaConverter();
        //Obtiene la clave de la solicitud reserva a anular
        String solicitudreservaString = converter.getAsString(FacesContext.getCurrentInstance(), null, solicitudreserva);
        String currentSolicitudreservaString = getRequestParameter("jsfcrud.currentSolicitudreserva");
        //Verifica que exista la solicitud reserva o que se haya seleccionado alguna disponible
        if (solicitudreservaString == null || solicitudreservaString.length() == 0 || !solicitudreservaString.equals(currentSolicitudreservaString)) {
            String outcome = rechazarSetup();
            if ("solicitudreserva_anular".equals(outcome)) {
                addErrorMessage("No se pudo realizar la operacion. Intente de nuevo.");
            }
            return outcome;
        }
        //Obtiene el administador de entidades
        EntityManager em = getEntityManager();
        try {
            utx.begin();
            //-- Se asigna todos los valores necesarios para la anulacion --
            Estadosolicitud idEstadoSolicitudNew = new Estadosolicitud(4); //Estado 4-ANULADO

            Tiporecurso idTipoRecursoNew = solicitudreserva.getIdTipoRecurso();
            Usuario idSolicitanteNew = solicitudreserva.getIdSolicitante();

            if (idEstadoSolicitudNew != null) {
                idEstadoSolicitudNew = em.getReference(idEstadoSolicitudNew.getClass(), idEstadoSolicitudNew.getIdEstadoSolicitud());
                solicitudreserva.setIdEstadoSolicitud(idEstadoSolicitudNew);
            }
            if (idTipoRecursoNew != null) {
                idTipoRecursoNew = em.getReference(idTipoRecursoNew.getClass(), idTipoRecursoNew.getIdTipoRecurso());
                solicitudreserva.setIdTipoRecurso(idTipoRecursoNew);
            }
            if (idSolicitanteNew != null) {
                idSolicitanteNew = em.getReference(idSolicitanteNew.getClass(), idSolicitanteNew.getIdUsuario());
                solicitudreserva.setIdSolicitante(idSolicitanteNew);
            }
            solicitudreserva = em.merge(solicitudreserva);
            //Para la audioria, que dispara el trigger de auditoria
            Usuario usuarioLogeado = (Usuario) session.getAttribute("user");
            solicitudreserva.setUserAudita(usuarioLogeado.getIdUsuario());
            utx.commit();
            addSuccessMessage("Solicitud Reserva anulado exitosamente.");
        } catch (Exception ex) { //Maneja el evento de la transaccion de usuario

            try {
                String msg = ex.getLocalizedMessage();
                if (msg != null && msg.length() > 0) {
                    addErrorMessage(msg);
                } else if (getSolicitudreservaFromRequest() == null) {
                    addErrorMessage("La solicitudreserva con id " + currentSolicitudreservaString + " no existe.");
                    utx.rollback();
                    return listSetup();
                } else {
                    addErrorMessage("Ocurrio un error de persistencia.");
                }
                utx.rollback();
            } catch (Exception e) { //Maneja el evento de la transaccion de rollback

                ensureAddErrorMessage(e, "Ocurrio un error intentando hacer rollback de la transaccion.");
            }
            return null;
        } finally {
            em.close();
        }
        return this.listSolicitudesPendientesSolicitanteSetup();
    }

    /**
     * Obtiene el idSolicitudReserva maximo para la siguiente nueva solicitud
     * @return El idSolicitudreserva siguiente
     */
    public int getItemMax() {
        if (itemCount == -1) {
            EntityManager em = getEntityManager();
            try {
                itemCount = ((Long) em.createQuery("select count(o) from Solicitudreserva as o").getSingleResult()).intValue();
                if (itemCount > 0) {
                    Solicitudreserva d = (Solicitudreserva) em.createQuery("SELECT s FROM Solicitudreserva as s order by s.idSolicitudReserva").getResultList().get(getLastItem() - 1);
                    itemCount = d.getIdSolicitudReserva();
                }
            } finally {
                em.close();
            }
        }
        return itemCount + 1;
    }

    /**
     * Realiza la transaccion de usuario que se encarga de aporbar una solicitudreserva.
     * Para ello realiza el chequeo de todos los valores antes de realizar el matcheo con los
     * atributos del JPA de la Base de Datos
     * @return El tag de la pagina que lista las solicitudes reservas pendientes
     */
    public String aprobar() {
        //Recupera los atributos de la sesion
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        SolicitudreservaConverter converter = new SolicitudreservaConverter();
        String solicitudreservaString = converter.getAsString(FacesContext.getCurrentInstance(), null, solicitudreserva);
        //Obtiene la clave de la solicitud reserva a aprobar
        String currentSolicitudreservaString = getRequestParameter("jsfcrud.currentSolicitudreserva");
        //Verifica que exista la solicitud reserva o que se haya seleccionado alguna disponible
        if (solicitudreservaString == null || solicitudreservaString.length() == 0 || !solicitudreservaString.equals(currentSolicitudreservaString)) {
            String outcome = aprobarSetup();
            if ("solicitudreserva_aprobar".equals(outcome)) {
                addErrorMessage("No se puede aprobar solicitudreserva.");
            }
            return outcome;
        }
        try {
            Date inicio = fechaHoraFormat.parse(this.getRequestParameter("fechaInicio") + " " + this.getRequestParameter("horaInicio"));
            Date fin = fechaHoraFormat.parse(this.getRequestParameter("fechaFin") + " " + this.getRequestParameter("horaFin"));
            inicio.setMinutes(inicio.getMinutes() + 1);
            //Validar el rango de fecha
            if (inicio.after(fin)) {
                addErrorMessage("La FECHA de Finalizacion debe ser mayor a la FECHA de Inicio");
                return "";
            }
        } catch (Exception e) {
            addErrorMessage("Error en los formatos de fechas y horas");
            return "";
        }
        //Se encarga de verificar que el rango seleccionado de la solicitudreserva
        //no se solape con otra reserva previamente aprobada
        if (this.verificarSolapamiento().length() > 0) {
            addErrorMessage(this.verificarSolapamiento());
            return "";
        }
        //Obtiene el administrador de entidades
        EntityManager em = getEntityManager();
        try {
            utx.begin();
            //-- Se asigna todos los valores necesarios para la aprobacion --
            Tiporecurso idTipoRecursoNew = solicitudreserva.getIdTipoRecurso();
            Usuario idSolicitanteNew = solicitudreserva.getIdSolicitante();
            Estadosolicitud idEstadoSolicitudNew = new Estadosolicitud(1); //Estado 1-APROBADO

            solicitudreserva.setFechaAprobacion(this.getFechaHoraActual());
            solicitudreserva.setHoraAprobacion(this.getFechaHoraActual());
            solicitudreserva.setIdRecurso(this.getIdRecursoSeleccionado().getIdRecurso());

            if (idEstadoSolicitudNew != null) {
                idEstadoSolicitudNew = em.getReference(idEstadoSolicitudNew.getClass(), idEstadoSolicitudNew.getIdEstadoSolicitud());
                solicitudreserva.setIdEstadoSolicitud(idEstadoSolicitudNew);
            }
            if (idTipoRecursoNew != null) {
                idTipoRecursoNew = em.getReference(idTipoRecursoNew.getClass(), idTipoRecursoNew.getIdTipoRecurso());
                solicitudreserva.setIdTipoRecurso(idTipoRecursoNew);
            }
            if (idSolicitanteNew != null) {
                idSolicitanteNew = em.getReference(idSolicitanteNew.getClass(), idSolicitanteNew.getIdUsuario());
                solicitudreserva.setIdSolicitante(idSolicitanteNew);
            }
            solicitudreserva = em.merge(solicitudreserva);
            //Para la audioria, que dispara el trigger de auditoria
            Usuario usuarioLogeado = (Usuario) session.getAttribute("user");
            solicitudreserva.setUserAudita(usuarioLogeado.getIdUsuario());

            utx.commit();
            addSuccessMessage("Solicitud Reserva fue aprobada exitosamente.");
        } catch (Exception ex) { //Maneja el evento de la transaccion del usuario

            try {
                String msg = ex.getLocalizedMessage();
                if (msg != null && msg.length() > 0) {
                    addErrorMessage(msg);
                } else if (getSolicitudreservaFromRequest() == null) {
                    addErrorMessage("La solicitudreserva con id " + currentSolicitudreservaString + " no existe.");
                    utx.rollback();
                    return listSetup();
                } else {
                    addErrorMessage("No se puede procesar la accion, verifique que se haya seleccionado la informaciÃ³n necesaria");
                }
                utx.rollback();
            } catch (Exception e) { //Maneja el evento de la transaccion rollback

                ensureAddErrorMessage(e, "Ocurrio un error intentando hacer rollback de la transaccion.");
            }
            return null;
        } finally {
            em.close();
        }
        return this.listSolicitudesPendientes();
    }

    /**
     * Obtiene una lista iterada de Recursos segun el tipo elegido en la solicitud
     * para poder ser desplegado en una lista seleccionable
     * @return La lista iterada de recursos
     */
    public SelectItem[] getRecursosPorTipoAvailableSelectOne() {
        try {
            return getRecursosPorTipoAvailable(true);
        } catch (Exception e) {
            this.addErrorMessage("No puede realizar este proceso");
            this.solicitudreserva.setIdTipoRecurso(new Tiporecurso(0));
            return getRecursosPorTipoAvailable(true);
        }

    }

    private SelectItem[] getRecursosPorTipoAvailable(boolean one) {
        List<Recurso> allRecursos = getRecursosPorTipo(true);
        int size = one ? allRecursos.size() + 1 : allRecursos.size();
        SelectItem[] items = new SelectItem[size];
        int i = 0;
        if (one) {
            items[0] = new SelectItem("", "---");
            i++;
        }
        for (Recurso x : allRecursos) {
            items[i++] = new SelectItem(x, x.toString());
        }
        return items;
    }

    /**
     * Obtiene una lista iterada de Recursos segun el tipo elegido en la solicitud
     * @return La lista iterada de recursos
     */
    public List<Recurso> getRecursosPorTipo() {
        if (recursos == null) {
            recursos = getRecursosPorTipo(false);
        }
        return recursos;
    }

    /**
     * Obtiene una lista iterada de todos los Recursos disponibles segun el tipo elegido en la solicitud
     * @return La lista iterada de recursos
     */
    public List<Recurso> getRecursosPorTipo(boolean all) {
        EntityManager em = getEntityManager();
        Tiporecurso TIPORECURSO = this.solicitudreserva.getIdTipoRecurso();
        try {
            Query q = em.createQuery("select object(o) from Recurso as o where o.idTipoRecurso.idTipoRecurso=" + TIPORECURSO.getIdTipoRecurso() + " and o.disponible=1");
            if (!all) {
                q.setMaxResults(batchSize);
                q.setFirstResult(getFirstItem());
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }
    private Recurso idRecursoSeleccionado;

    /**
     * Fija el valor del recurso seleccionado al valor especificado
     * @param idRecursoSeleccionado El idRecursoSeleccionado
     */
    public void setIdRecursoSeleccionado(Recurso idRecursoSeleccionado) {
        this.idRecursoSeleccionado = idRecursoSeleccionado;
    }

    /**
     * Obtiene el IdRecursoSeleccionado de la Solicitudreserva Controller
     * @return El IdRecursoSeleccionado
     */
    public Recurso getIdRecursoSeleccionado() {
        return this.idRecursoSeleccionado;
    }

    /**
     * Obtiene la fecha y hora actual del sistema
     * @return La fecha y hora actual del sistema
     */
    public Date getFechaHoraActual() {
        Date date = new Date();
        return date;
    }

    /**
     * Verifica el solapamiento del rango de fecha-hora con la reserva
     * a los efectos de evitar conflictos en el procesamiento
     * @return Un mensaje de finalizacion de chequeo
     */
    private String verificarSolapamiento() {
        EntityManager em = getEntityManager();
        Recurso RECURSOSELECCIONADO = new Recurso(this.getIdRecursoSeleccionado().getIdRecurso());
        String SQL;
        String finicio, ffin, hinicio, hfin;
        finicio = dateFormat.format(solicitudreserva.getFechaInicio());
        hinicio = horaFormat.format(solicitudreserva.getHoraInicio());
        ffin = dateFormat.format(solicitudreserva.getFechaFin());
        hfin = horaFormat.format(solicitudreserva.getHoraFin());
        try {
            SQL = "select f_verificar_solapamientohorario('" + finicio + "','" + hinicio + "','" + ffin + "','" + hfin + "','" + RECURSOSELECCIONADO.getIdRecurso() + "')";
            Query q = em.createNativeQuery(SQL);
            Vector v = new Vector();
            v = (Vector) q.getSingleResult();
            String s = (String) v.get(0);
            return s;
        } finally {
            em.close();
        }

    }

    /**
     * Obtiene una lista iterada de solicitudes reserva pendientes del solicitante
     * Todas estas solicitudes pueden ser anuladas unicamente por el solicitante
     * @return La lista iterada de solicitudes reserva pendientes
     */
    public List<Solicitudreserva> getSolicitudreservasPendientesSolicitante() {
        if (solicitudreservas == null) {
            solicitudreservas = getSolicitudreservasPendientesSolicitante(false);
        }
        return solicitudreservas;
    }

    /**
     * Obtiene la lista iterada de las solicitudes de reservas pendiente del solicitante seleccionado
     * @param all Un boolean indicando que se traera todas las solicitudes reservas pendientes
     * @return La lista iterada de pendientes
     */
    public List<Solicitudreserva> getSolicitudreservasPendientesSolicitante(boolean all) {
        //Obtiene los atributos de la sesion
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        Usuario usuarioLogeado = (Usuario) session.getAttribute("user");
        EntityManager em = getEntityManager();
        //Efectua la consulta conforme a los parametros de usuario y solicitudreserva
        String SQL = "select object(o) from Solicitudreserva as o where o.idEstadoSolicitud.idEstadoSolicitud=3 and o.idSolicitante.idUsuario like '" + usuarioLogeado.getIdUsuario() + "'";
        try {
            //Es el select de solamente las solicitudes con estado pendientes
            Query q = em.createQuery(SQL);
            if (!all) {
                q.setMaxResults(batchSize);
                q.setFirstResult(getFirstItem());
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    /**
     * Obtiene el tag de la pagina de solicitudes de reservas pendientes del aprobador
     * @return El tag de la pagina de solicitudes de reserva pendientes del aprobador
     */
    public String listSolicitudesPendientesSolicitanteSetup() {
        reset(true);
        return "ListSolicitudesPendientesSolicitante";
    }

    /**
     * Obtiene el tag de la pagina de solicitudes de reservas pendientes del solicitante
     * @return El tag de la pagina de solicitudes de reserva pendientes del solicitante
     */
    public String listSolicitudesPendientesSetup() {
        reset(true);
        return "ListSolicitudesPendientes";
    }
}

